<?php
/**
 * @version		1.0.0 gerenciador_de_arquivos $
 * @package		gerenciador_de_arquivos
 * @copyright	Copyright © 2012 - All rights reserved.
 * @license		GNU/GPL
 * @author		Edio Hanoway Kepke
 * @author mail	hanoway12@gmail.com 
 */

// no direct access
defined('_JEXEC') or die('Restricted access');
jimport('joomla.application.component.controller');
//require_once(dirname(__FILE__).DS.'helpers'.DS.'assunto.php');
require_once(dirname(__FILE__).DS.'helpers'.DS.'assuntoDAO.php');
require_once(dirname(__FILE__).DS.'helpers'.DS.'arquivoDAO.php');
require_once(dirname(__FILE__).DS.'helpers'.DS.'autorDAO.php');
require_once(dirname(__FILE__).DS.'helpers'.DS.'arquivoassuntoDAO.php');
require_once(dirname(__FILE__).DS.'helpers'.DS.'arquivoautorDAO.php');
require_once(dirname(__FILE__).DS.'helpers'.DS.'tools'.DS.'error.php');
require_once(dirname(__FILE__).DS.'helpers'.DS.'tools'.DS.'fum.php');

class gerenciador_de_arquivosController extends JController
{    
    function __construct()
    {
            parent::__construct();
    }
            
    public function display($cachable = false, $urlparams = false)
    {            
        switch (JRequest::getVar("task"))
        {
            case "getassunto" : $this->getAssuntos(); break;
            case "getautor" : $this->getAutores(); break;
            case "insert": $this->insertArquivo(); break;
            case "pesquisar": $this->pesquisar(); break;
            case "deletar": $this->deletarArquivo(); break;
            case "editar": $this->editar(); break;
            default: parent::display();break;
        }
    }
    
    private function editar()
    {
        $user = JFactory::getUser(); 
                        
        if($user->id && !is_null($user->id))
        {
            $file= JRequest::getVar("file");

            if(!is_null($file) && $file)
            {     
                                                
                $filePermision = dirname(__FILE__).DS.'assets'.DS.'json'.DS.'user_groups.json';
                
                if(file_exists($filePermision))
                {                                           
                    $userGroups = json_decode(file_get_contents($filePermision));
                    
                    $hasPermicionUser = false;
                    
                    foreach ($user->groups as $id_group) 
                    {                        
                        if(in_array($id_group, $userGroups))
                        {
                            $hasPermicionUser = TRUE;
                            break;
                        }                        
                    }
                                                                                                    
                    $arquivoDao = ArquivoDAO::instance();                        
                    $arquivoDao->setDb($this->getDB());
                                                                                                                      
                    $arquivo = $arquivoDao->selectArquivoForDelete($file["id"]);
                    

                    if(isset($arquivo["id_dono"]))
                    {                    
                        $isOwner = ($arquivo["id_dono"] ==  $user->id);
                    }                    
                                        
                    if($hasPermicionUser || $isOwner)
                    {      
                        $upadateFIle = $arquivoDao->update($file);
                        
                        
                        if(isset($file['removeAssunto']))
                        {
                            $arquivoAssuntoDao = ArquivoAssuntoDAO::instance();
                            $arquivoAssuntoDao->setDb($this->getDB());                        
                            foreach ($file['removeAssunto'] as $idAssunto) 
                            {
                                $arquivoAssuntoDao->deleteForIdFileIdAssunto($file["id"], $idAssunto);
                            }
                        }
                        
                        if(isset($file['removeAutor']))
                        {
                            $arquivoAutorDao = ArquivoAutorDAO::instance();
                            $arquivoAutorDao->setDb($this->getDB());
                            foreach ($file['removeAutor'] as $idAutor)
                            {
                                $arquivoAutorDao->deleteForIdFileIdAutor($file["id"], $idAutor);
                            }
                        }
                        
                        if(isset($file['addAssunto']))
                        {                            
                            $idAssuntos = $this->getIdsAssunto($file['addAssunto']);
                            $this->bindArquivoAssunto($file["id"], $idAssuntos);                            
                        }
                        
                        if(isset($file['addAutor']))
                        {
                            $idAutores= $this->getIdsAutores($file['addAutor']);                                                        
                            $this->bindArquivoAutor($file["id"], $idAutores);
                        }
                        
                        if($upadateFIle)
                        {
                            echo json_encode(Fum::getArrayReturn(Error::NOT_EXIST_ERROR));  
                            jexit();
                            return;
                        }
                    }
                    else
                    {
                        echo json_encode(Fum::getArrayReturn(Error::INVALID_OWNER));
                        jexit();
                        return;
                    }                    
                }   
                
                echo json_encode(Fum::getArrayReturn(Error::INTERNAL_SERVER_ERROR));
            }
            else
            {
                echo json_encode(Fum::getArrayReturn(Error::INSUFFICIENT_PARAMETERS));
            }
        }
        else
        {
            echo json_encode(Fum::getArrayReturn(Error::NOT_EXIST_LOGIN_USER));
        }
        jexit();
    }

    

    private function pesquisar()
    {                
        $options = JRequest::getVar("options");
        
        if(!is_null($options) && $options)
        {       
            $options = (object)$options;
            
            $arquivoDao = ArquivoDAO::instance();                        
            $arquivoDao->setDb($this->getDB());
            
            $arquivos = $arquivoDao->select($options);            
                                    
            if($arquivos)
            {                                
                echo json_encode(Fum::getArrayReturn(Error::NOT_EXIST_ERROR, $arquivos));
            }
            else
            {
                echo json_encode(Fum::getArrayReturn(Error::NOT_FOUND_REGISTRY));
            }
        }
        else
        {
            echo json_encode(Fum::getArrayReturn(Error::INSUFFICIENT_PARAMETERS));
        }
        
        jexit();        
        return;
        
    }

    private function getAssuntos()
    {            
        $condition = JRequest::getVar("text");
                
        if(!is_null($condition) && $condition)
        {                
            $assuntoDao = AssuntoDAO::instance();
            $assuntoDao->setDb($this->getDB());
            $assuntos = $assuntoDao->selectLike($condition."%");                        
            
            if($assuntos)
            {
                echo json_encode($assuntos);                
            }
            else
            {
                echo json_encode(array());
            }
        }
        else
        {
            echo json_encode(array());
        }
        jexit();            
    }
    
    private function getAutores()
    {            
        $condition = JRequest::getVar("text");

        if(!is_null($condition) && $condition)
        {                
            $autorDao = AutorDAO::instance();
            $autorDao->setDb($this->getDB());
            $autores = $autorDao->selectLike($condition."%");
            if($autores)
            {
                echo json_encode($autores);                
            }
            else
            {
                echo json_encode(array());
            }
        }
        else 
        {
            echo json_encode(array());
        }        
        jexit();            
    }

    private function insertArquivo()
    {                                                             
        $idDono = $this->getIdUser();

        if($idDono && !is_null($idDono))
        {                        
            $info_file = json_decode(urldecode(JRequest::getVar("arquivo", false, "POST")),true);
            
            $file = JRequest::getVar("arquivo", false, "FILES");                                    
                                                
            $info_file["id_dono"] = $idDono;
            
            if(!is_null($info_file) && $info_file && $file && !is_null($file))
            {                                
                
                $idAutores= $this->getIdsAutores($info_file["autor"]);
                $idAssuntos = $this->getIdsAssunto($info_file["assunto"]);
                
                if(empty($idAutores) || empty($idAssuntos) )
                {
                    echo json_encode(Fum::getArrayReturn(Error::INTERNAL_SERVER_ERROR));                    
                }
                
                $info_file["file"] = $this->uploadFile($file,$info_file);
                
                if(is_numeric($info_file["file"]))
                {                          
                    echo json_encode(Fum::getArrayReturn($info_file["file"]));
                    jexit();
                    return;
                }
                else
                {                        
                    $arquivoDao = ArquivoDAO::instance();                
                    $arquivoDao->setDb($this->getDB());
                
                    $idArquivo = $arquivoDao->insert($info_file,true);
                                                                                
                    if(is_numeric($idArquivo) && $idArquivo)
                    {
                        $this->bindArquivoAssunto($idArquivo, $idAssuntos);
                        $this->bindArquivoAutor($idArquivo, $idAutores);
                        echo json_encode(Fum::getArrayReturn(Error::NOT_EXIST_ERROR));
                    }                                                            
                    else
                    {
                        echo json_encode(Fum::getArrayReturn(Error::INTERNAL_SERVER_ERROR));
                    }
                }
                
                                       
            }
            else
            {
                echo json_encode(Fum::getArrayReturn(Error::INSUFFICIENT_PARAMETERS));
            }
        }
        else
        {
            echo json_encode(Fum::getArrayReturn(Error::NOT_EXIST_LOGIN_USER));
        }
        jexit();
    }
    
    private function deletarArquivo()
    {                                                             
        $user = JFactory::getUser(); 
                        
        if($user->id && !is_null($user->id))
        {
            $idFile = JRequest::getVar("id");

            if(!is_null($idFile) && $idFile)
            {                
                $filePermision = dirname(__FILE__).DS.'assets'.DS.'json'.DS.'user_groups.json';
                
                if(file_exists($filePermision))
                {                    
                    $userGroups = json_decode(file_get_contents($filePermision));
                    
                    $hasPermicionUser = false;
                    
                    foreach ($user->groups as $id_group) 
                    {                        
                        if(in_array($id_group, $userGroups))
                        {
                            $hasPermicionUser = TRUE;
                            break;
                        }                        
                    }
                    
                    $db = $this->getDB();
                    
                    $arquivoDao = ArquivoDAO::instance();                        
                    $arquivoDao->setDb($db);
                                                                                                                      
                    $arquivo = $arquivoDao->selectArquivoForDelete($idFile);
                    
                    
                    if(isset($arquivo["id_dono"]))
                    {                    
                        $isOwner = ($arquivo["id_dono"] ==  $user->id);
                    }                    
                                        
                    if($hasPermicionUser || $isOwner)
                    {                                                
                        $urlFile = getcwd().$arquivo["url_arquivo"];
                                                                                                
                        if(file_exists($urlFile))
                        {                            
                            $db->transactionStart();
                                
                            $arquivoAssuntoDao = ArquivoAssuntoDAO::instance();
                            $arquivoAssuntoDao->setDb($db);
                            
                            $arquivoAutorDao = ArquivoAutorDAO::instance();
                            $arquivoAutorDao->setDb($db);

                            $ad = $arquivoDao->delete($idFile);
                            
                            $asd = $arquivoAssuntoDao->deleteForIdFile($idFile);
                            
                            $aad = $arquivoAutorDao->deleteForIdFile($idFile);
                            
//                            echo "aad".json_encode($aad);
//                            echo "asd".json_encode($asd);
//                            echo "ad".json_encode($ad);
                            
                            if($asd && $aad && $ad)
                            {
                                if(@unlink($urlFile))
                                {
                                    echo json_encode(Fum::getArrayReturn(Error::NOT_EXIST_ERROR));
                                    $db->transactionCommit();
                                    jexit();
                                    return;
                                }
                            }
                            
                            $db->transactionRollback();
                        }
                        else
                        {                        
                            echo json_encode(Fum::getArrayReturn(Error::NOT_FOUND_FILE));
                            jexit();
                            return;
                        }
                    }
                    else
                    {                    
                        echo json_encode(Fum::getArrayReturn(Error::INVALID_OWNER));
                        jexit();
                        return;
                    }
                }   
                
                echo json_encode(Fum::getArrayReturn(Error::INTERNAL_SERVER_ERROR));
            }
            else
            {
                echo json_encode(Fum::getArrayReturn(Error::INSUFFICIENT_PARAMETERS));
            }
        }
        else
        {
            echo json_encode(Fum::getArrayReturn(Error::NOT_EXIST_LOGIN_USER));
        }
        jexit();
    }
    
    private function getIdsAssunto($listArquivo)
    {        
        $idsAssuntos = array();
        
        $assuntoDao = AssuntoDAO::instance();
        
        $assuntoDao->setDb($this->getDB());
        
        foreach ($listArquivo as $assunto) 
        {                        
            $assuntoObj = $assuntoDao->selectObject($assunto);
            if(!is_null($assuntoObj))
            {
                $idsAssuntos[] = $assuntoObj->id;
            }
            else
            {
                $id = $assuntoDao->insert($assunto, true);
                if(is_numeric($id) && $id)
                {
                    $idsAssuntos[] = $id;
                }                
            }
        }
        
        return $idsAssuntos;
    }
    
    private function getIdsAutores($listAutores)
    {
        $idsAutores = array();
        
        $autorDao = AutorDAO::instance();
        
        $autorDao->setDb($this->getDB());
        
        foreach ($listAutores as $autor) 
        {                        
            $autorObj = $autorDao->selectObject($autor);
            if(!is_null($autorObj))
            {
                $idsAutores[] = $autorObj->id;
            }
            else
            {
                $id = $autorDao->insert($autor, true);
                if(is_numeric($id) && $id)
                {
                    $idsAutores[] = $id;
                }                
            }
        }
        
        return $idsAutores;                                       
    }    
   
    private function bindArquivoAssunto($idArquivo, $idAssuntos)
    {                
        $arquivoAssuntoDao = ArquivoAssuntoDAO::instance();
        
        $arquivoAssuntoDao->setDb($this->getDB());
        
        foreach ($idAssuntos as $idAssunto)
        {                        
            $arquivoassuntoObj = $arquivoAssuntoDao->selectObject($idArquivo, $idAssunto);
            if(is_null($arquivoassuntoObj))
            {
                $arquivoAssuntoDao->insert($idArquivo, $idAssunto);                
            }            
        }                                
    }
    
    private function bindArquivoAutor($idArquivo, $idsAutor)
    {
        $arquivoAutorDao = ArquivoAutorDAO::instance();
        
        $arquivoAutorDao->setDb($this->getDB());
                
        foreach ($idsAutor as $idAutor)
        {                        
            $arquivoAutorObj = $arquivoAutorDao->selectObject($idArquivo, $idAutor);
                        
            if(is_null($arquivoAutorObj))
            {    
                $arquivoAutorDao->insert($idArquivo, $idAutor);                
            }            
        }          
    }

    private function getIdUser()
    {
        $user = JFactory::getUser();        
        return $user->id;
    }        

    private function uploadFile($file, $info_file)
    {                                                
        //setar variaveis de ambiente
        ini_set("upload_max_filesize",  Arquivo::MAX_FILE_UPLOAD."M");
        ini_set("memory_limit",  Arquivo::MAX_FILE_UPLOAD."M");
        ini_set("post_max_size",  Arquivo::MAX_FILE_UPLOAD."M");
                        
        $info_file = (object) $info_file;
        $file = (object) $file;
        
        //verifica se não teve erro no upload
        if ($file->error != 0) 
        {                                                                    
            switch ($file->error) 
            {
                case 1: return Error::FILE_SIZE_EXCEPTION_PHP;
                case 2: return Error::FILE_SIZE_EXCEPTION_HTML;
                case 3: return Error::FILE_PARCIAL_UPLOAD;
                case 4: return Error::FILE_NOT_UPLOAD;                
                default : return Error::INTERNAL_SERVER_ERROR;
            }                        
        }                
        
        //verifica e a extensão do arquivo e valida
        $extensao = strtolower(end(explode('.', $file->name)));                                        
        
        if (!$this->isPermittedFile($extensao)) 
        {            
            return Error::FILE_IS_NOT_ALLOWED;
        }                
                                                                            
//        if (Arquivo::MAX_FILE_UPLOAD < ($file->size/(1024*1024))) 
//        {
//            return Error::FILE_IS_VERY_BIG;
//        }
                                
        $urlbase = getcwd();
        
        $tipos_permitidos = json_decode('["tcc","tese","artigo","sic","dissertacoes","video", "imagem"]');
        
        if(!in_array($info_file->tipo, $tipos_permitidos))
        {
            return Error::INTERNAL_SERVER_ERROR;
        }
        
        
        $uploaddir = '/files_gerenciador_de_arquivos/'.$info_file->tipo."/".$info_file->ano."/".$info_file->id_dono;
                        
        //cria diretorios se estes não existirem
        if(!file_exists($urlbase.$uploaddir))
        {
            $this->createFolder($urlbase.$uploaddir);
        }
        
        //setar o nome do arquivo
        $nomeFinal = time().Fum::cleanWord($file->name, array("removeAccentuation" => true, "lowercase" => true, "removeSpace" => "_"));
                                               
        if (move_uploaded_file($file->tmp_name, $urlbase.$uploaddir."/".$nomeFinal))
        {
            return $uploaddir."/".$nomeFinal;
        }    
                        
        return Error::INTERNAL_SERVER_ERROR;                                                      
    }
    
    public function createFolder($url)
    {       
        @mkdir($url, 0777, true);        
    }
    
    public static function isSuper()
    {
        $hasPermicionUser = false;
        
        $user = JFactory::getUser(); 
                        
        if($user->id && !is_null($user->id))
        {
                       
            $filePermision = dirname(__FILE__).DS.'assets'.DS.'json'.DS.'user_groups.json';
                
            if(file_exists($filePermision))
            {                    
                $userGroups = json_decode(file_get_contents($filePermision));
                                    
                foreach ($user->groups as $id_group) 
                {                        
                    if(in_array($id_group, $userGroups))
                    {
                        $hasPermicionUser = TRUE;
                        break;
                    }                        
                }
            }
        }
        
        return $hasPermicionUser;
    }
    
    public static function isPermittedFile($ext)
    {                
        $url_not_permitted_file = dirname(__FILE__).DS.'assets'.DS.'json'.DS.'not_permitted_file.json';
                        
        if(file_exists($url_not_permitted_file))
        {                       
            $not_permitted_file = json_decode(file_get_contents($url_not_permitted_file));
                                                
            if(in_array($ext, $not_permitted_file))                    
            {                
                return false;
            }                                    
        }
        
        return true;
    }
    
    
    private function getDB()
    {
        $conf =& JFactory::getConfig();

//        $host 		= '127.0.0.1';
//        $user 		= 'lelic';
//        $password 	= 'MAllc/?';
//        $database	= 'lelic';
//        $prefix 	= '';
//        $driver 	= 'mysql';        
        $host 		= 'bdlivre.ufrgs.br';
        $user 		= 'lelic';
        $password 	= 'MAllc/?';
        $database	= 'lelic';
        $prefix 	= '';
        $driver 	= 'mysql';        

        $options	= array ( 'driver' => $driver, 'host' => $host, 'user' => $user, 'password' => $password, 'database' => $database, 'prefix' => $prefix );

        $db =& JDatabase::getInstance( $options );

        if ( JError::isError($db) ) 
        {
            die(json_encode(Fum::getArrayReturn(Error::INTERNAL_SERVER_ERROR)));
//            return FALSE;
        }

        if ($db->getErrorNum() > 0) 
        {
            die(json_encode(Fum::getArrayReturn(Error::INTERNAL_SERVER_ERROR)));
//            return FALSE;
        }
        
        
        return $db;
    }
}



?>